﻿
#include "DNF定义.h"
#include "Engine/common.h"
#include "strid.h"

#pragma warning(disable:4305)

class DNF技能对象_圣洁之光 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣洁之光;
		名称=L"圣洁之光";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=15;
		等级上限=70;
		精通等级=60;
		版本等级=51;
		TP学习等级=50;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=4.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			28.51, 31.40, 34.29, 37.18, 40.08,  42.97, 45.86, 48.75, 51.64, 54.54, 
			57.43, 60.32, 63.21, 66.11, 69.00,  71.89, 74.78, 77.67, 80.57, 83.46, 
			86.35, 89.24, 92.13, 95.03, 97.92,  100.81, 103.70, 106.60, 109.49, 112.38, 
			115.27, 118.16, 121.06, 123.95, 126.84,  129.73, 132.63, 135.52, 138.41, 141.30, 
			144.19, 147.09, 149.98, 152.87, 155.76,  158.66, 161.55, 164.44, 167.33, 170.22, 
			173.12, 176.01, 178.90, 181.79, 184.68,  187.58, 190.47, 193.36, 196.25, 199.15, 
			202.04, 204.93, 207.82, 210.71, 213.61,  216.50, 219.39, 222.28, 225.18, 228.07, 
		};
		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+圣洁之光;
		符文起始ResId=RID_符文图标_奶妈+圣洁之光符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_胜利之矛 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=胜利之矛;
		名称=L"胜利之矛";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=20;
		等级上限=70;
		精通等级=60;
		版本等级=48;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=7.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			22.14, 24.38, 26.63, 28.87, 31.11,  33.37, 35.61, 37.86, 40.10, 42.34, 
			44.59, 46.84, 49.09, 51.33, 53.58,  55.82, 58.07, 60.32, 62.56, 64.81, 
			67.05, 69.29, 71.55, 73.79, 76.04,  78.28, 80.53, 82.77, 85.03, 87.27, 
			89.51, 91.76, 94.00, 96.26, 98.50,  100.74, 102.99, 105.23, 107.48, 109.73, 
			111.98, 114.22, 116.46, 118.71, 120.96,  123.21, 125.45, 127.69, 129.94, 132.18, 
			134.44, 136.68, 138.93, 141.17, 143.41,  145.66, 147.91, 150.16, 152.40, 154.65, 
			156.89, 159.14, 161.39, 163.63, 165.88,  168.12, 170.36, 172.62, 174.86, 177.11, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			33.20, 36.58, 39.94, 43.31, 46.68,  50.05, 53.42, 56.78, 60.15, 63.53, 
			66.89, 70.26, 73.63, 77.00, 80.37,  83.73, 87.11, 90.48, 93.84, 97.21, 
			100.59, 103.95, 107.32, 110.69, 114.06,  117.43, 120.79, 124.16, 127.54, 130.90, 
			134.27, 137.65, 141.01, 144.38, 147.74,  151.12, 154.49, 157.85, 161.22, 164.60, 
			167.96, 171.33, 174.70, 178.07, 181.44,  184.80, 188.18, 191.55, 194.91, 198.28, 
			201.66, 205.02, 208.39, 211.76, 215.13,  218.50, 221.86, 225.23, 228.61, 231.97, 
			235.34, 238.72, 242.08, 245.45, 248.81,  252.19, 255.56, 258.92, 262.29, 265.67, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+胜利之矛;
		符文起始ResId=RID_符文图标_奶妈+胜利之矛符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_圣光守护 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣光守护;
		名称=L"圣光守护";
		所属职业=职业_光明骑士女;
		技能类型=增益技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=25;
		等级上限=60;
		精通等级=50;
		版本等级=31;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(0);
		冷却时间=20.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			115.85, 134.31, 152.78, 171.25, 189.72,  208.19, 226.66, 245.12, 263.59, 282.06, 
			300.53, 319.00, 337.46, 355.93, 374.40,  392.87, 411.34, 429.80, 448.27, 466.74, 
			485.21, 503.68, 522.15, 540.61, 559.08,  577.55, 596.02, 614.49, 632.95, 651.42, 
			669.89, 688.36, 706.83, 725.29, 743.76,  762.23, 780.70, 799.17, 817.64, 836.10, 
			854.57, 873.04, 891.51, 909.98, 928.44,  946.91, 965.38, 983.85, 1002.32, 1020.78, 
			1039.25, 1057.72, 1076.19, 1094.66, 1113.12,  1131.59, 1150.06, 1168.53, 1187.00, 1205.47, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+圣光守护;
		符文起始ResId=RID_符文图标_奶妈+圣光守护符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//每个队友增加10%伤害，由职业类负责处理
		float 基础伤害=(数据表[0])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_洗礼之光 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=洗礼之光;
		名称=L"洗礼之光";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=25;
		等级上限=70;
		精通等级=60;
		版本等级=46;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=7.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			57.52, 63.36, 69.19, 75.03, 80.86,  86.70, 92.54, 98.37, 104.21, 110.04, 
			115.88, 121.72, 127.55, 133.39, 139.22,  145.06, 150.90, 156.73, 162.57, 168.40, 
			174.24, 180.08, 185.91, 191.75, 197.58,  203.42, 209.26, 215.09, 220.93, 226.76, 
			232.60, 238.44, 244.27, 250.11, 255.94,  261.78, 267.62, 273.45, 279.29, 285.12, 
			290.96, 296.80, 302.63, 308.47, 314.29,  320.14, 325.98, 331.80, 337.65, 343.47, 
			349.31, 355.14, 360.98, 366.82, 372.65,  378.49, 384.32, 390.16, 396.00, 401.83, 
			407.67, 413.50, 419.34, 425.18, 431.01,  436.85, 442.68, 448.52, 454.36, 460.19, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+洗礼之光;
		符文起始ResId=RID_符文图标_奶妈+洗礼之光符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_神光惩戒 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=神光惩戒;
		名称=L"神光惩戒";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=30;
		等级上限=70;
		精通等级=60;
		版本等级=43;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=10.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			15.93, 17.55, 19.16, 20.77, 22.39,  24.01, 25.63, 27.25, 28.85, 30.47, 
			32.09, 33.71, 35.33, 36.93, 38.55,  40.17, 41.79, 43.41, 45.03, 46.63, 
			48.25, 49.87, 51.49, 53.11, 54.72,  56.33, 57.95, 59.57, 61.19, 62.80, 
			64.42, 66.03, 67.65, 69.27, 70.88,  72.50, 74.12, 75.74, 77.35, 78.96, 
			80.58, 82.20, 83.82, 85.44, 87.04,  88.66, 90.28, 91.90, 93.52, 95.14, 
			96.74, 98.36, 99.98, 101.60, 103.22,  104.82, 106.44, 108.06, 109.68, 111.30, 
			112.91, 114.52, 116.14, 117.76, 119.38,  120.99, 122.61, 124.22, 125.84, 127.46, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			23.90, 26.31, 28.74, 31.17, 33.60,  36.01, 38.44, 40.87, 43.29, 45.71, 
			48.14, 50.57, 52.99, 55.41, 57.84,  60.26, 62.69, 65.11, 67.54, 69.96, 
			72.39, 74.81, 77.23, 79.66, 82.09,  84.51, 86.93, 89.36, 91.79, 94.20, 
			96.63, 99.06, 101.47, 103.90, 106.33,  108.76, 111.17, 113.60, 116.03, 118.45, 
			120.87, 123.30, 125.73, 128.15, 130.58,  133.00, 135.42, 137.85, 140.28, 142.70, 
			145.12, 147.55, 149.98, 152.39, 154.82,  157.25, 159.66, 162.09, 164.52, 166.95, 
			169.36, 171.79, 174.22, 176.64, 179.06,  181.49, 183.92, 186.34, 188.76, 191.19, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			39.82, 43.87, 47.90, 51.95, 55.99,  60.03, 64.07, 68.11, 72.15, 76.20, 
			80.23, 84.28, 88.31, 92.36, 96.41,  100.44, 104.49, 108.52, 112.57, 116.60, 
			120.65, 124.69, 128.73, 132.77, 136.81,  140.85, 144.89, 148.93, 152.98, 157.01, 
			161.06, 165.09, 169.14, 173.17, 177.22,  181.26, 185.30, 189.34, 193.38, 197.42, 
			201.47, 205.50, 209.55, 213.58, 217.63,  221.66, 225.71, 229.76, 233.79, 237.84, 
			241.87, 245.92, 249.96, 254.00, 258.04,  262.08, 266.12, 270.16, 274.20, 278.25, 
			282.28, 286.33, 290.36, 294.41, 298.44,  302.49, 306.53, 310.57, 314.61, 318.65, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_奶妈+神光惩戒;
		符文起始ResId=RID_符文图标_奶妈+神光惩戒符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级]+(数据表[2])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_圣光烬盾 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣光烬盾;
		名称=L"圣光烬盾";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=30;
		等级上限=70;
		精通等级=60;
		版本等级=43;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=10.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			24.55, 27.03, 29.52, 32.02, 34.51,  36.99, 39.48, 41.98, 44.47, 46.95, 
			49.45, 51.94, 54.43, 56.92, 59.41,  61.90, 64.39, 66.89, 69.37, 71.86, 
			74.35, 76.85, 79.34, 81.82, 84.31,  86.81, 89.30, 91.78, 94.28, 96.77, 
			99.26, 101.74, 104.24, 106.73, 109.22,  111.72, 114.20, 116.69, 119.18, 121.68, 
			124.16, 126.65, 129.14, 131.64, 134.13,  136.61, 139.11, 141.60, 144.09, 146.57, 
			149.07, 151.56, 154.05, 156.53, 159.03,  161.52, 164.01, 166.51, 168.99, 171.48, 
			173.98, 176.47, 178.95, 181.44, 183.94,  186.43, 188.91, 191.40, 193.90, 196.39, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			57.27, 63.09, 68.90, 74.71, 80.52,  86.34, 92.14, 97.96, 103.77, 109.57, 
			115.39, 121.19, 127.01, 132.82, 138.63,  144.44, 150.26, 156.06, 161.88, 167.69, 
			173.50, 179.31, 185.13, 190.93, 196.74,  202.56, 208.36, 214.18, 219.98, 225.80, 
			231.61, 237.42, 243.23, 249.05, 254.85,  260.67, 266.48, 272.29, 278.10, 283.92, 
			289.72, 295.53, 301.35, 307.15, 312.97,  318.77, 324.59, 330.40, 336.21, 342.02, 
			347.84, 353.64, 359.46, 365.27, 371.08,  376.89, 382.70, 388.51, 394.32, 400.14, 
			405.94, 411.76, 417.57, 423.38, 429.19,  435.01, 440.81, 446.63, 452.43, 458.25, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+圣光烬盾;
		符文起始ResId=RID_符文图标_奶妈+圣光烬盾符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_勇气颂歌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=勇气颂歌;
		名称=L"勇气颂歌";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=35;
		等级上限=70;
		精通等级=60;
		版本等级=27;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=40.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			13.79, 15.99, 18.18, 20.39, 22.59,  24.78, 26.99, 29.19, 31.38, 33.59, 
			35.78, 37.98, 40.19, 42.38, 44.58,  46.79, 48.98, 51.18, 53.38, 55.58, 
			57.78, 59.98, 62.18, 64.37, 66.58,  68.78, 70.97, 73.18, 75.37, 77.57, 
			79.78, 81.97, 84.17, 86.38, 88.57,  90.77, 92.97, 95.17, 97.37, 99.57, 
			101.77, 103.96, 106.17, 108.37, 110.56,  112.77, 114.96, 117.16, 119.37, 121.56, 
			123.76, 125.95, 128.16, 130.36, 132.55,  134.76, 136.96, 139.15, 141.36, 143.55, 
			145.75, 147.96, 150.16, 152.36, 154.56,  156.76, 158.96, 161.16, 163.36, 165.56, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+勇气颂歌;
		符文起始ResId=RID_符文图标_奶妈+勇气颂歌符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级];
		if (应用护石)
		{
			基础伤害=基础伤害*22;	//22段
			基础伤害*=1.23f;
		}
		else
		{
			基础伤害=基础伤害*20;	//20段
		}
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_神圣锁环 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=神圣锁环;
		名称=L"神圣锁环";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=35;
		等级上限=70;
		精通等级=60;
		版本等级=41;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=18.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			2.45, 2.70, 2.95, 3.19, 3.44,  3.70, 3.95, 4.19, 4.44, 4.70, 
			4.94, 5.19, 5.44, 5.68, 5.94,  6.19, 6.43, 6.68, 6.94, 7.19, 
			7.43, 7.68, 7.94, 8.18, 8.43,  8.68, 8.92, 9.18, 9.43, 9.67, 
			9.92, 10.18, 10.43, 10.67, 10.92,  11.17, 11.42, 11.67, 11.92, 12.16, 
			12.42, 12.67, 12.91, 13.16, 13.41,  13.66, 13.91, 14.16, 14.40, 14.66, 
			14.91, 15.16, 15.40, 15.65, 15.91,  16.15, 16.40, 16.65, 16.90, 17.15, 
			17.40, 17.64, 17.90, 18.15, 18.40,  18.64, 18.89, 19.15, 19.39, 19.64, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			74.49, 82.05, 89.60, 97.16, 104.71,  112.28, 119.83, 127.39, 134.95, 142.50, 
			150.06, 157.61, 165.18, 172.73, 180.29,  187.85, 195.40, 202.96, 210.52, 218.08, 
			225.63, 233.19, 240.75, 248.30, 255.86,  263.42, 270.98, 278.53, 286.09, 293.65, 
			301.20, 308.77, 316.32, 323.88, 331.43,  338.99, 346.55, 354.10, 361.67, 369.22, 
			376.78, 384.33, 391.89, 399.45, 407.01,  414.57, 422.12, 429.68, 437.23, 444.79, 
			452.35, 459.91, 467.47, 475.02, 482.58,  490.13, 497.69, 505.26, 512.81, 520.37, 
			527.92, 535.48, 543.03, 550.60, 558.16,  565.71, 573.27, 580.82, 588.38, 595.93, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+神圣锁环;
		符文起始ResId=RID_符文图标_奶妈+神圣锁环符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]*13+(数据表[1])[等级];	//13段+1段
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_忏悔之雷 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=忏悔之雷;
		名称=L"忏悔之雷";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=40;
		等级上限=70;
		精通等级=60;
		版本等级=38;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=18.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			15.26, 16.82, 18.35, 19.91, 21.46,  23.01, 24.56, 26.10, 27.65, 29.20, 
			30.75, 32.30, 33.84, 35.39, 36.95,  38.50, 40.05, 41.59, 43.14, 44.69, 
			46.24, 47.79, 49.33, 50.88, 52.43,  53.99, 55.54, 57.08, 58.63, 60.18, 
			61.73, 63.28, 64.82, 66.37, 67.92,  69.47, 71.03, 72.57, 74.12, 75.67, 
			77.22, 78.77, 80.31, 81.86, 83.41,  84.96, 86.51, 88.05, 89.61, 91.16, 
			92.71, 94.26, 95.80, 97.35, 98.90,  100.45, 102.00, 103.54, 105.09, 106.65, 
			108.20, 109.75, 111.29, 112.84, 114.39,  115.94, 117.49, 119.03, 120.58, 122.13, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			76.33, 84.08, 91.82, 99.56, 107.31,  115.05, 122.80, 130.54, 138.29, 146.03, 
			153.77, 161.52, 169.26, 177.01, 184.75,  192.50, 200.24, 207.98, 215.73, 223.47, 
			231.22, 238.96, 246.71, 254.45, 262.20,  269.94, 277.68, 285.43, 293.17, 300.92, 
			308.66, 316.41, 324.15, 331.89, 339.64,  347.38, 355.13, 362.87, 370.62, 378.36, 
			386.11, 393.85, 401.59, 409.34, 417.08,  424.83, 432.57, 440.32, 448.06, 455.80, 
			463.55, 471.29, 479.04, 486.78, 494.53,  502.27, 510.01, 517.76, 525.50, 533.25, 
			540.99, 548.74, 556.48, 564.23, 571.97,  579.71, 587.46, 595.20, 602.95, 610.69, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+忏悔之雷;
		符文起始ResId=RID_符文图标_奶妈+忏悔之雷符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害1=(数据表[0])[等级];
		float 基础伤害2=(数据表[1])[等级];
		if (应用护石)
		{
			基础伤害1=0;
			基础伤害2*=1.0+PC(100)+PC(42);
		}
		else
		{
			基础伤害1*=5;	//5段
		}
		float TP增伤=1.0+TP等级*PC(10);
		return (基础伤害1+基础伤害2)*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		if (应用护石)
			return 冷却时间*(1.0-PC(10));
		return 冷却时间;
	}
};

class DNF技能对象_神光十字 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=神光十字;
		名称=L"神光十字";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=45;
		等级上限=70;
		精通等级=60;
		版本等级=36;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=2;
		手搓冷却缩减=PC(2);
		冷却时间=45.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			126.36, 139.17, 152.00, 164.81, 177.64,  190.45, 203.27, 216.09, 228.91, 241.73, 
			254.55, 267.36, 280.19, 293.00, 305.83,  318.64, 331.46, 344.28, 357.10, 369.92, 
			382.74, 395.55, 408.38, 421.19, 434.02,  446.83, 459.66, 472.47, 485.29, 498.11, 
			510.93, 523.74, 536.57, 549.38, 562.21,  575.02, 587.85, 600.66, 613.48, 626.30, 
			639.12, 651.94, 664.76, 677.57, 690.40,  703.22, 716.04, 728.86, 741.67, 754.50, 
			767.31, 780.14, 792.95, 805.78, 818.59,  831.41, 844.23, 857.05, 869.86, 882.69, 
			895.50, 908.33, 921.14, 933.97, 946.78,  959.60, 972.42, 985.24, 998.06, 1010.88, 

		};

		float 数据表2[技能等级上限]={
			0.0f,
			189.54, 208.77, 227.99, 247.22, 266.45,  285.68, 304.91, 324.13, 343.37, 362.59, 
			381.82, 401.05, 420.28, 439.51, 458.73,  477.97, 497.20, 516.42, 535.65, 554.89, 
			574.11, 593.34, 612.56, 631.80, 651.03,  670.25, 689.48, 708.71, 727.94, 747.17, 
			766.40, 785.63, 804.85, 824.08, 843.32,  862.54, 881.77, 900.99, 920.23, 939.46, 
			958.68, 977.91, 997.15, 1016.37, 1035.60,  1054.83, 1074.06, 1093.29, 1112.51, 1131.75, 
			1150.97, 1170.20, 1189.43, 1208.66, 1227.89,  1247.11, 1266.34, 1285.58, 1304.80, 1324.03, 
			1343.27, 1362.49, 1381.72, 1400.94, 1420.18,  1439.41, 1458.63, 1477.86, 1497.09, 1516.32, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+神光十字;
		符文起始ResId=RID_符文图标_奶妈+神光十字符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害1=(数据表[0])[等级];
		float 基础伤害2=(数据表[1])[等级];
		if (应用护石)
		{
			基础伤害1*=1.0f+PC(11);
			基础伤害2*=1.0f+PC(11)+PC(23);
		}
		float TP增伤=1.0+TP等级*PC(10);
		return (基础伤害1+基础伤害2)*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		if (应用护石)
			return 冷却时间*(1.0-PC(12));	
		return 冷却时间;
	}
};

class DNF技能对象_圣光天启 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣光天启;
		名称=L"圣光天启";
		所属职业=职业_光明骑士女;
		技能类型=觉醒技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=50;
		等级上限=50;
		精通等级=40;
		版本等级=14;

		无色数量=5;
		手搓冷却缩减=PC(5);
		冷却时间=170.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			20.70, 25.50, 30.31, 35.11, 39.91,  44.71, 49.52, 54.32, 59.12, 63.92, 
			68.73, 73.53, 78.33, 83.14, 87.94,  92.74, 97.54, 102.35, 107.15, 111.95, 
			116.75, 121.56, 126.36, 131.16, 135.97,  140.77, 145.57, 150.37, 155.18, 159.98, 
			164.78, 169.58, 174.39, 179.19, 183.99,  188.79, 193.60, 198.40, 203.20, 208.01, 
			212.81, 217.61, 222.41, 227.22, 232.02,  236.82, 241.62, 246.43, 251.23, 256.02, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			615.40, 758.10, 900.81, 1043.51, 1186.21,  1328.92, 1471.61, 1614.31, 1757.01, 1899.72, 
			2042.42, 2185.12, 2327.83, 2470.53, 2613.23,  2755.94, 2898.64, 3041.34, 3184.04, 3326.75, 
			3469.45, 3612.15, 3754.86, 3897.56, 4040.26,  4182.95, 4325.66, 4468.36, 4611.06, 4753.77, 
			4896.47, 5039.17, 5181.88, 5324.58, 5467.28,  5609.98, 5752.69, 5895.39, 6038.09, 6180.80, 
			6323.50, 6466.20, 6608.91, 6751.61, 6894.31,  7037.00, 7179.71, 7322.41, 7465.11, 7607.82, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+圣光天启;

		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//一觉三觉柔化会损失20%伤害，由职业类负责处理
		float 基础伤害=(数据表[0])[等级]*16+(数据表[1])[等级];	//16段+1段
		if (等级>=3)
			基础伤害*=1.1f;
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		//忏悔重击护石可以减冷却，上限25s，一直放技能大约60s就可以吃满，但前提是组队
		//固定减冷却与70%上限无关，难以量化，而且波动很大，计算时不考虑
		return 冷却时间;
	}
};


class DNF技能对象_忏悔重击 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=忏悔重击;
		名称=L"忏悔重击";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=60;
		等级上限=50;
		精通等级=40;
		版本等级=28;
		TP学习等级=60;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=2;
		手搓冷却缩减=PC(2);
		冷却时间=30.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			107.06, 117.93, 128.79, 139.65, 150.50,  161.36, 172.23, 183.09, 193.95, 204.81, 
			215.67, 226.54, 237.40, 248.26, 259.12,  269.98, 280.85, 291.71, 302.57, 313.43, 
			324.29, 335.16, 346.02, 356.88, 367.74,  378.60, 389.47, 400.33, 411.19, 422.05, 
			432.91, 443.78, 454.64, 465.49, 476.35,  487.21, 498.08, 508.94, 519.80, 530.66, 
			541.52, 552.39, 563.25, 574.11, 584.97,  595.83, 606.70, 617.56, 628.42, 639.28, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			160.59, 176.88, 193.18, 209.47, 225.76,  242.05, 258.35, 274.64, 290.94, 307.22, 
			323.51, 339.81, 356.10, 372.40, 388.68,  404.98, 421.27, 437.57, 453.86, 470.14, 
			486.44, 502.73, 519.03, 535.32, 551.61,  567.90, 584.20, 600.49, 616.79, 633.07, 
			649.36, 665.66, 681.95, 698.25, 714.53,  730.83, 747.12, 763.42, 779.71, 795.99, 
			812.29, 828.58, 844.88, 861.17, 877.46,  893.75, 910.05, 926.34, 942.64, 958.92, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+忏悔重击;
		符文起始ResId=RID_符文图标_奶妈+忏悔重击符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害1=(数据表[0])[等级];
		float 基础伤害2=(数据表[1])[等级];

		if (应用护石)
		{
			基础伤害1*=1.0f-PC(45);
			基础伤害2*=(1.0f-PC(45))*(1.0f+PC(29));	//第三段29%伤害
		}
		float TP增伤=1.0+TP等级*PC(10);
		return (基础伤害1+基础伤害2)*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		//护石15s填充一次，填充速度受冷却影响
		//护石初始可用2次，实际比正常多了一次，计算时不考虑
		if (应用护石)
			return 15.0*(1.0-PC(11));
		return 冷却时间;
	}
};


class DNF技能对象_圣洁之翼 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣洁之翼;
		名称=L"圣洁之翼";
		所属职业=职业_光明骑士女;
		技能类型=增益技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=70;
		等级上限=50;
		精通等级=40;
		版本等级=23;
		TP学习等级=70;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=2;
		手搓冷却缩减=PC(0);
		冷却时间=50.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			458.59, 505.11, 551.63, 598.15, 644.69,  691.21, 737.73, 784.25, 830.77, 877.31, 
			923.83, 970.35, 1016.87, 1063.39, 1109.92,  1156.45, 1202.97, 1249.49, 1296.01, 1342.54, 
			1389.06, 1435.59, 1482.11, 1528.63, 1575.16,  1621.68, 1668.20, 1714.73, 1761.25, 1807.78, 
			1854.30, 1900.82, 1947.35, 1993.87, 2040.40,  2086.92, 2133.44, 2179.96, 2226.50, 2273.02, 
			2319.54, 2366.06, 2412.58, 2459.12, 2505.64,  2552.16, 2598.68, 2645.20, 2691.73, 2738.26, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+圣洁之翼;
		符文起始ResId=RID_符文图标_奶妈+圣洁之翼符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//每个队友增加10%伤害，由职业类负责处理
		float 基础伤害=(数据表[0])[等级];
		if (应用护石)
		{
			基础伤害*=1.14f;
			基础伤害*=1.2f;	//0.5s跳一次，共20段，每段1%
		}
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_圣佑之阵 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣佑之阵;
		名称=L"圣佑之阵";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=FALSE;

		学习等级=75;
		等级上限=50;
		精通等级=40;
		版本等级=21;

		无色数量=3;
		手搓冷却缩减=PC(5);
		冷却时间=50.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			867.13, 955.10, 1043.07, 1131.04, 1219.01,  1306.98, 1394.95, 1482.92, 1570.89, 1658.87, 
			1746.83, 1834.81, 1922.77, 2010.75, 2098.71,  2186.69, 2274.65, 2362.63, 2450.59, 2538.57, 
			2626.53, 2714.51, 2802.48, 2890.45, 2978.42,  3066.39, 3154.36, 3242.33, 3330.30, 3418.27, 
			3506.24, 3594.21, 3682.18, 3770.16, 3858.12,  3946.10, 4034.06, 4122.04, 4210.00, 4297.98, 
			4385.94, 4473.92, 4561.88, 4649.86, 4737.82,  4825.80, 4913.77, 5001.74, 5089.71, 5177.68, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+圣佑之阵;
		符文起始ResId=RID_符文图标_奶妈+圣佑之阵符文*5;
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//装备特性的[强力一击]3级及以后可以强化此技能
		//条件是施放完二觉，接下来2次冷却-70%
		//条件过于复杂，计算时不考虑
		float 基础伤害=(数据表[0])[等级];
		if (应用护石)
			基础伤害*=1.0+PC(17)+PC(20);
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_圣光普照 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣光普照;
		名称=L"圣光普照";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=FALSE;

		学习等级=80;
		等级上限=50;
		精通等级=40;
		版本等级=18;

		无色数量=5;
		手搓冷却缩减=PC(5);
		冷却时间=40.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			82.37, 90.73, 99.09, 107.45, 115.80,  124.16, 132.51, 140.87, 149.23, 157.59, 
			165.95, 174.31, 182.66, 191.01, 199.37,  207.73, 216.09, 224.45, 232.81, 241.16, 
			249.51, 257.87, 266.23, 274.59, 282.95,  291.31, 299.66, 308.01, 316.37, 324.73, 
			333.09, 341.45, 349.81, 358.17, 366.51,  374.87, 383.23, 391.59, 399.95, 408.31, 
			416.67, 425.01, 433.37, 441.73, 450.09,  458.45, 466.81, 475.17, 483.52, 491.87, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+圣光普照;
		符文起始ResId=RID_符文图标_奶妈+圣光普照符文*5;
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//没带护石时，且只有一个敌人时增伤10%，由职业类负责处理
		float 基础伤害=(数据表[0])[等级];
		if (应用护石)
		{
			基础伤害*=12;	//12段
			基础伤害*=1.09f;
		}
		else
		{
			基础伤害*=10;	//10段
		}
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_救赎彼岸_惩戒圣枪 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=救赎彼岸_惩戒圣枪;
		名称=L"救赎彼岸:惩戒圣枪";
		所属职业=职业_光明骑士女;
		技能类型=觉醒技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=85;
		等级上限=50;
		精通等级=40;
		版本等级=7;

		无色数量=10;
		手搓冷却缩减=PC(5);
		冷却时间=180.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			776.06, 956.01, 1135.97, 1315.92, 1495.88,  1675.83, 1855.79, 2035.75, 2215.70, 2395.66, 
			2575.61, 2755.57, 2935.53, 3115.48, 3295.44,  3475.39, 3655.35, 3835.30, 4015.26, 4195.22, 
			4375.17, 4555.14, 4735.08, 4915.05, 5095.01,  5274.96, 5454.92, 5634.87, 5814.83, 5994.78, 
			6174.74, 6354.70, 6534.65, 6714.61, 6894.56,  7074.51, 7254.46, 7434.41, 7614.36, 7794.31, 
			7974.26, 8154.21, 8334.16, 8514.11, 8694.06,  8874.01, 9053.96, 9233.91, 9413.86, 9593.81, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			1164.09, 1434.01, 1703.95, 1973.89, 2243.82,  2513.76, 2783.69, 3053.63, 3323.56, 3593.49, 
			3863.42, 4133.36, 4403.29, 4673.23, 4943.17,  5213.10, 5483.04, 5752.96, 6022.90, 6292.83, 
			6562.77, 6832.70, 7102.64, 7372.57, 7642.51,  7912.43, 8182.37, 8452.30, 8722.24, 8992.18, 
			9262.11, 9532.05, 9801.97, 10071.91, 10341.84,  10611.77, 10881.70, 11151.63, 11421.56, 11691.49, 
			11961.42, 12231.35, 12501.28, 12771.21, 13041.14,  13311.07, 13581.00, 13850.93, 14120.86, 14390.79, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+救赎彼岸_惩戒圣枪;
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级];
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_圣言十字 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣言十字;
		名称=L"圣言十字";
		所属职业=职业_光明骑士女;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=95;
		等级上限=50;
		精通等级=40;
		版本等级=11;

		无色数量=7;
		手搓冷却缩减=PC(5);
		冷却时间=60.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			336.32, 370.44, 404.56, 438.68, 472.80,  506.92, 541.04, 575.16, 609.28, 643.40, 
			677.52, 711.64, 745.76, 779.88, 814.00,  848.12, 882.24, 916.36, 950.48, 984.60, 
			1018.72, 1052.84, 1086.96, 1121.08, 1155.20,  1189.32, 1223.44, 1257.56, 1291.68, 1325.80, 
			1359.92, 1394.04, 1428.16, 1462.28, 1496.40,  1530.52, 1564.64, 1598.76, 1632.88, 1667.00, 
			1701.12, 1735.24, 1769.36, 1803.48, 1837.60,  1871.72, 1905.84, 1939.96, 1974.08, 2008.20, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			21.02, 23.15, 25.28, 27.41, 29.54,  31.67, 33.81, 35.94, 38.07, 40.21, 
			42.34, 44.48, 46.61, 48.74, 50.87,  53.00, 55.14, 57.27, 59.40, 61.53, 
			63.66, 65.79, 67.92, 70.05, 72.18,  74.31, 76.44, 78.57, 80.70, 82.83, 
			84.96, 87.09, 89.22, 91.35, 93.48,  95.61, 97.74, 99.87, 102.00, 104.13, 
			106.26, 108.39, 110.52, 112.65, 114.78,  116.91, 119.04, 121.17, 123.30, 125.43, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			924.89, 1018.72, 1112.55, 1206.39, 1300.21,  1394.04, 1487.87, 1581.71, 1675.53, 1769.36, 
			1863.19, 1957.03, 2050.86, 2144.68, 2238.51,  2332.35, 2426.18, 2520.00, 2613.83, 2707.67, 
			2801.50, 2895.33, 2989.16, 3082.99, 3176.82,  3270.65, 3364.48, 3458.31, 3552.14, 3645.97, 
			3739.80, 3833.63, 3927.46, 4021.29, 4115.12,  4208.95, 4302.78, 4396.61, 4490.44, 4584.27, 
			4678.10, 4771.93, 4865.76, 4959.59, 5053.42,  5147.25, 5241.08, 5334.91, 5428.74, 5522.57, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_奶妈+圣言十字;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级]*20+(数据表[2])[等级];	//1段+20段+1段
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_祈愿_天使赞歌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=祈愿_天使赞歌;
		名称=L"祈愿·天使赞歌";
		所属职业=职业_光明骑士女;
		技能类型=觉醒技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=100;
		等级上限=50;
		精通等级=40;
		版本等级=4;

		无色数量=15;
		手搓冷却缩减=PC(5);
		冷却时间=290.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			225.10, 277.30, 329.50, 381.70, 433.90,  486.10, 538.29, 590.49, 642.69, 694.89, 
			747.09, 799.29, 851.49, 903.68, 955.88,  1008.08, 1060.28, 1112.48, 1164.68, 1216.88, 
			1269.08, 1321.28, 1373.48, 1425.68, 1477.88,  1530.08, 1582.28, 1634.48, 1686.68, 1738.88, 
			1791.08, 1843.28, 1895.48, 1947.68, 1999.88,  2052.08, 2104.28, 2156.48, 2208.68, 2260.88, 
			2313.08, 2365.28, 2417.48, 2469.68, 2521.88,  2574.08, 2626.28, 2678.48, 2730.68, 2782.88, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			3376.59, 4159.56, 4942.54, 5725.52, 6508.51,  7291.49, 8074.47, 8857.45, 9640.42, 10423.40, 
			11206.38, 11989.36, 12772.34, 13555.32, 14338.29,  15121.27, 15904.25, 16687.23, 17470.21, 18253.19, 
			19036.17, 19819.15, 20602.13, 21385.11, 22168.09,  22951.07, 23734.05, 24517.03, 25300.01, 26082.99, 
			26865.97, 27648.95, 28431.93, 29214.91, 29997.89,  30780.87, 31563.85, 32346.83, 33129.81, 33912.79, 
			34695.77, 35478.75, 36261.73, 37044.71, 37827.69,  38610.67, 39393.65, 40176.63, 40959.61, 41742.59, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+祈愿_天使赞歌;
		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//三觉绑定一觉时，一觉没施放，不产生伤害
		float 基础伤害=(数据表[0])[等级]*10+(数据表[1])[等级];	//10段+1段
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

//被动技能
//////////////////////////////////////////////////////////////////////////
class DNF技能对象_圣光灌注 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣光灌注;
		名称=L"圣光灌注";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;

		学习等级=1;
		等级上限=1;
		精通等级=1;
		版本等级=1;

		数据表数量=0;

		ResId=RID_技能图标_奶妈+圣光灌注;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//组队改属性伤害增加，三次为乘算，攻击立即生效一次，叠满为1.045的3次方
		
		//单人改单刷属性 独立增加，冷却减少

		//单人+CP武器 额外加独立，加算后再乘算
	}
};

class DNF技能对象_启示_惩戒 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=启示_惩戒;
		名称=L"启示:惩戒";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;

		学习等级=1;
		等级上限=1;
		精通等级=1;
		版本等级=1;

		数据表数量=0;
		
		ResId=RID_技能图标_奶妈+启示_惩戒;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//攻速增加

		//技攻增加
	}
};

class DNF技能对象_启示_颂歌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=启示_颂歌;
		名称=L"启示:颂歌";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;
		
		学习等级=15;
		等级上限=70;
		精通等级=60;
		版本等级=34;

		//智力
		float 数据表1[技能等级上限]={
			0.0f,
			86, 90, 94, 98, 102,  107, 112, 117, 123, 129, 
			135, 141, 147, 154, 161,  169, 177, 185, 193, 201, 
			210, 219, 229, 238, 248,  258, 269, 279, 290, 301, 
			313, 325, 337, 349, 361,  375, 388, 401, 415, 429, 
			443, 457, 473, 487, 503,  519, 535, 551, 567, 584, 
			598, 614, 630, 646, 662,  677, 693, 709, 725, 741, 
			756, 772, 788, 804, 820,  835, 851, 867, 883, 899, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_奶妈+启示_颂歌;

		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//智力增加
	}
};

class DNF技能对象_光杖精通 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=光杖精通;
		名称=L"光杖精通";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;

		学习等级=20;
		等级上限=20;
		精通等级=10;
		版本等级=10;

		//独立提升
		float 数据表1[技能等级上限]={
			0.0f,
			PC(6.5), PC(8.0), PC(9.5), PC(11.0), PC(12.5), 
			PC(14.0), PC(15.5), PC(17.0), PC(18.5), PC(20.0), 
			PC(21.5), PC(23.0), PC(24.5), PC(26.0), PC(27.5), 
			PC(29.0), PC(30.5), PC(32.0), PC(33.5), PC(35.0), 
		};

		//施放速度
		float 数据表2[技能等级上限]={
			0.0f,
			PC(6.0), PC(7.0), PC(8.0), PC(9.0), PC(10.0), 
			PC(11.0), PC(12.0), PC(13.0), PC(14.0), PC(15.0), 
			PC(16.0), PC(17.0), PC(18.0), PC(19.0), PC(20.0), 
			PC(21.0), PC(22.0), PC(23.0), PC(24.0), PC(25.0), 
		};

		//魔法暴击
		float 数据表3[技能等级上限]={
			0.0f,
			PC(15.5), PC(16.0), PC(16.5), PC(17.0), PC(17.5), 
			PC(18.0), PC(18.5), PC(19.0), PC(19.5), PC(20.0), 
			PC(20.5), PC(21.0), PC(21.5), PC(22.0), PC(22.5), 
			PC(23.0), PC(23.5), PC(24.0), PC(24.5), PC(25.0), 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_奶妈+光杖精通;

		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//独立提升 施放速度
		//独立提升应该在最后计算，需要先累积独立
	}
};

class DNF技能对象_虔诚信念 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=虔诚信念;
		名称=L"虔诚信念";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;

		学习等级=48;
		等级上限=50;
		精通等级=40;
		版本等级=23;

		//智力
		float 数据表1[技能等级上限]={
			0.0f,
			14, 37, 59, 82, 104,  127, 149, 172, 194, 217, 
			239, 262, 284, 307, 329,  352, 374, 397, 419, 442, 
			464, 487, 509, 532, 554,  577, 599, 622, 644, 667, 
			689, 712, 734, 757, 779,  802, 824, 847, 869, 892, 
			914, 937, 959, 982, 1004,  1027, 1049, 1072, 1094, 1117, 
		};

		//技攻
		float 数据表2[技能等级上限]={
			0.0f,
			PC(11.0), PC(12.0), PC(13.0), PC(14.0), PC(15.0), 
			PC(16.0), PC(17.0), PC(18.0), PC(19.0), PC(20.0), 
			PC(21.0), PC(22.0), PC(23.0), PC(24.0), PC(25.0), 
			PC(26.0), PC(27.0), PC(28.0), PC(29.0), PC(30.0), 
			PC(31.5), PC(33.0), PC(34.5), PC(36.0), PC(37.5), 
			PC(39.0), PC(40.5), PC(42.0), PC(43.5), PC(45.0), 
			PC(46.5), PC(48.0), PC(49.5), PC(51.0), PC(52.5), 
			PC(54.0), PC(55.5), PC(57.0), PC(58.5), PC(60.0), 
			PC(61.5), PC(63.0), PC(64.5), PC(66.0), PC(67.5), 
			PC(69.0), PC(70.5), PC(72.0), PC(73.5), PC(75.0), 
		};

		//攻速/移速
		float 数据表3[技能等级上限]={
			0.0f,
			PC(4.2), PC(4.6), PC(5.0), PC(5.4), PC(5.8), 
			PC(6.3), PC(6.7), PC(7.1), PC(7.5), PC(7.9), 
			PC(8.3), PC(8.8), PC(9.2), PC(9.6), PC(10.0), 
			PC(10.4), PC(10.8), PC(11.3), PC(11.7), PC(12.1), 
			PC(12.5), PC(12.9), PC(13.3), PC(13.8), PC(14.2), 
			PC(14.6), PC(15.0), PC(15.4), PC(15.8), PC(16.3), 
			PC(16.7), PC(17.1), PC(17.5), PC(17.9), PC(18.3), 
			PC(18.8), PC(19.2), PC(19.6), PC(20.0), PC(20.4), 
			PC(20.8), PC(21.3), PC(21.7), PC(22.1), PC(22.5), 
			PC(22.9), PC(23.3), PC(23.8), PC(24.2), PC(24.6), 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_奶妈+虔诚信念;

		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//智力 技攻 攻速 移速
	}
};

class DNF技能对象_大天使的庇护 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=大天使的庇护;
		名称=L"大天使的庇护";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;

		学习等级=75;
		等级上限=50;
		精通等级=40;
		版本等级=14;

		//智力
		float 数据表1[技能等级上限]={
			0.0f,
			150, 160, 170, 180, 190,  200, 210, 220, 230, 240, 
			250, 260, 270, 280, 290,  300, 310, 320, 330, 340, 
			350, 360, 370, 380, 390,  400, 410, 420, 430, 440, 
			450, 460, 470, 480, 490,  500, 510, 520, 530, 540, 
			550, 560, 570, 580, 590,  600, 610, 620, 630, 640, 
		};

		//暴伤
		float 数据表2[技能等级上限]={
			0.0f,
			PC(16.0), PC(18.0), PC(20.0), PC(22.0), PC(24.0), 
			PC(26.0), PC(28.0), PC(30.0), PC(32.0), PC(34.0), 
			PC(36.0), PC(38.0), PC(40.0), PC(42.0), PC(44.0), 
			PC(46.0), PC(48.0), PC(50.0), PC(52.0), PC(54.0), 
			PC(56.0), PC(58.0), PC(60.0), PC(62.0), PC(64.0), 
			PC(66.0), PC(68.0), PC(70.0), PC(72.0), PC(74.0), 
			PC(76.0), PC(78.0), PC(80.0), PC(82.0), PC(84.0), 
			PC(86.0), PC(88.0), PC(90.0), PC(92.0), PC(94.0), 
			PC(96.0), PC(98.0), PC(100.0), PC(102.0), PC(104.0), 
			PC(106.0), PC(108.0), PC(110.0), PC(112.0), PC(114.0), 
		};

		//魔法暴击
		float 数据表3[技能等级上限]={
			0.0f,
			PC(5.0), PC(6.0), PC(7.0), PC(8.0), PC(9.0), 
			PC(10.0), PC(11.0), PC(12.0), PC(13.0), PC(14.0), 
			PC(15.0), PC(16.0), PC(17.0), PC(18.0), PC(19.0), 
			PC(20.0), PC(21.0), PC(22.0), PC(23.0), PC(24.0), 
			PC(25.0), PC(26.0), PC(27.0), PC(28.0), PC(29.0), 
			PC(30.0), PC(31.0), PC(32.0), PC(33.0), PC(34.0), 
			PC(35.0), PC(36.0), PC(37.0), PC(38.0), PC(39.0), 
			PC(40.0), PC(41.0), PC(42.0), PC(43.0), PC(44.0), 
			PC(45.0), PC(46.0), PC(47.0), PC(48.0), PC(49.0), 
			PC(50.0), PC(51.0), PC(52.0), PC(53.0), PC(54.0), 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_奶妈+大天使的庇护;

		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//暴击才会触发暴伤增加

		//智力 暴伤
	}
};

class DNF技能对象_圣天使之光 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圣天使之光;
		名称=L"圣天使之光";
		所属职业=职业_光明骑士女;
		技能类型=被动技能;

		学习等级=95;
		等级上限=50;
		精通等级=40;
		版本等级=7;

		//智力
		float 数据表1[技能等级上限]={
			0.0f,
			160, 170, 180, 190, 200,  210, 220, 230, 240, 250, 
			260, 270, 280, 290, 300,  310, 320, 330, 340, 350, 
			360, 370, 380, 390, 400,  410, 420, 430, 440, 450, 
			460, 470, 480, 490, 500,  510, 520, 530, 540, 550, 
			560, 570, 580, 590, 600,  610, 620, 630, 640, 650, 
		};

		//技攻
		float 数据表2[技能等级上限]={
			0.0f,
			PC(20.0), PC(22.0), PC(24.0), PC(26.0), PC(28.0), 
			PC(30.0), PC(32.0), PC(34.0), PC(36.0), PC(38.0), 
			PC(40.0), PC(42.0), PC(44.0), PC(46.0), PC(48.0), 
			PC(50.0), PC(52.0), PC(54.0), PC(56.0), PC(58.0), 
			PC(60.0), PC(62.0), PC(64.0), PC(66.0), PC(68.0), 
			PC(70.0), PC(72.0), PC(74.0), PC(76.0), PC(78.0), 
			PC(80.0), PC(82.0), PC(84.0), PC(86.0), PC(88.0), 
			PC(90.0), PC(92.0), PC(94.0), PC(96.0), PC(98.0), 
			PC(100.0), PC(102.0), PC(104.0), PC(106.0), PC(108.0), 
			PC(110.0), PC(112.0), PC(114.0), PC(116.0), PC(118.0), 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_奶妈+圣天使之光;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//智力 技攻 （这个被动好像计入系统奶）
	}
};






//职业类需要考虑这些：
//圣光守护队友 圣洁之翼队友 一觉柔化 圣光普照敌人数
//被动需要判断条件 武器精通 圣光灌注单刷

class DNF光明骑士女 : public DNF职业对象
{
public:
	virtual void 初始化()
	{
		职业=职业_光明骑士女;
		攻击类型=魔法攻击类型;
		是否固伤=TRUE;
		是否辅助=TRUE;
		//技能总数量=25;
		主动技能数量=18;
		被动技能数量=7;
		被动技能索引=18;

		技能总数量=0;
		std::vector<DNF技能对象*>::iterator it;
		for (it=技能对象表.begin();it!=技能对象表.end();it++)
		{
			if ((*it)->所属职业==职业_光明骑士女)
			{
				职业技能列表[技能总数量]=*it;
				技能总数量++;
			}	
		}

		Buff图标ResId=RID_BUFF技能图标_奶妈;

		//每次设置变更时，由转换函数填充设置相关的字段
		//每次重新计算时，由计算核心重置并填充动态数据
	}

	virtual void 应用职业基本数据(PVOID 角色对象)
	{
		//待实现
	}

	virtual void 应用被动技能(int 技能索引,PVOID 角色对象)
	{
		//待实现
	}

	virtual double 计算技能单次伤害(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}

	virtual double 计算技能总伤害(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}

	virtual double 计算技能冷却(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}

	virtual int 计算技能等级(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}
};

void 添加技能对象_奶妈()
{
	int Size=技能对象表.size();
	技能对象表.push_back(new DNF技能对象_圣洁之光);
	技能对象表.push_back(new DNF技能对象_胜利之矛);
	技能对象表.push_back(new DNF技能对象_圣光守护);
	技能对象表.push_back(new DNF技能对象_洗礼之光);
	技能对象表.push_back(new DNF技能对象_神光惩戒);
	技能对象表.push_back(new DNF技能对象_圣光烬盾);
	技能对象表.push_back(new DNF技能对象_勇气颂歌);
	技能对象表.push_back(new DNF技能对象_神圣锁环);
	技能对象表.push_back(new DNF技能对象_忏悔之雷);
	技能对象表.push_back(new DNF技能对象_神光十字);
	技能对象表.push_back(new DNF技能对象_圣光天启);
	技能对象表.push_back(new DNF技能对象_忏悔重击);
	技能对象表.push_back(new DNF技能对象_圣洁之翼);
	技能对象表.push_back(new DNF技能对象_圣佑之阵);
	技能对象表.push_back(new DNF技能对象_圣光普照);
	技能对象表.push_back(new DNF技能对象_救赎彼岸_惩戒圣枪);
	技能对象表.push_back(new DNF技能对象_圣言十字);
	技能对象表.push_back(new DNF技能对象_祈愿_天使赞歌);
	技能对象表.push_back(new DNF技能对象_圣光灌注);
	技能对象表.push_back(new DNF技能对象_启示_惩戒);
	技能对象表.push_back(new DNF技能对象_启示_颂歌);
	技能对象表.push_back(new DNF技能对象_光杖精通);
	技能对象表.push_back(new DNF技能对象_虔诚信念);
	技能对象表.push_back(new DNF技能对象_大天使的庇护);
	技能对象表.push_back(new DNF技能对象_圣天使之光);
	std::vector<DNF技能对象*>::iterator it;
	for (it=技能对象表.begin()+Size;it!=技能对象表.end();it++)
		(*it)->初始化();
}

void 添加职业对象_奶妈()
{
	auto Object=new DNF光明骑士女;
	Object->初始化();
	职业对象表.push_back(Object);
}